package org.aplombh.java.awcing.basic.graph.shortestPath.floyd;

import java.util.Scanner;

/**
 * 给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，边权可能为负数。
 * <p>
 * 再给定 k 个询问，每个询问包含两个整数 x 和 y，表示查询从点 x 到点 y 的最短距离，如果路径不存在，则输出 impossible。
 * <p>
 * 数据保证图中不存在负权回路。
 * <p>
 * 输入格式
 * 第一行包含三个整数 n,m,k。
 * <p>
 * 接下来 m 行，每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。
 * <p>
 * 接下来 k 行，每行包含两个整数 x,y，表示询问点 x 到点 y 的最短距离。
 * <p>
 * 输出格式
 * 共 k 行，每行输出一个整数，表示询问的结果，若询问两点间不存在路径，则输出 impossible。
 * <p>
 * 数据范围
 * 1≤n≤200,
 * 1≤k≤n2
 * 1≤m≤20000,
 * 图中涉及边长绝对值均不超过 10000。
 * <p>
 * 输入样例：
 * 3 3 2
 * 1 2 1
 * 2 3 2
 * 1 3 1
 * 2 1
 * 1 3
 * 输出样例：
 * impossible
 * 1
 */
public class Floyd_854 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        int q = scanner.nextInt();
        Floyd floyd = new Floyd(n);
        for (int i = 0; i < m; i++) {
            int a = scanner.nextInt();
            int b = scanner.nextInt();
            int w = scanner.nextInt();
            floyd.d[a][b] = Math.min(floyd.d[a][b], w);
        }

        floyd.floyd();

        for (int i = 0; i < q; i++) {
            int a = scanner.nextInt();
            int b = scanner.nextInt();
            int l = floyd.get(a, b);
            if (l >= 1 << 30)
                System.out.println("impossible");
            else
                System.out.println(l);
        }
    }
}

class Floyd {
    public static final int N = 210;
    int[][] d = new int[N][N];
    int[][] path = new int[N][N];   // 存储路径：从第k个点到该点位最短路径
    int n;

    Floyd(int n) {
        init(n);
    }

    void init(int n) {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                if (i == j) d[i][j] = 0;
                else d[i][j] = 1 << 30;
            }
        }
        this.n = n;
    }

    void floyd() {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                for (int k = 1; k <= n; k++) {
                    if (d[i][j] > d[i][k] + d[k][j]) {
                        d[i][j] = d[i][k] + d[k][j];
                        path[i][j] = k;
                    }
                }
            }
        }
    }

    int get(int a, int b) {
        return d[a][b];
    }
}
